import datetime

from flask import Response, jsonify, Flask, request, Blueprint,url_for
from configs import *
from modules.Tables import *




# 创建蓝图，对应的register目录
user_view = Blueprint('user_view', __name__)


# 登录接口获取token
@user_view.route('/login', methods=['GET'])
# @jwt_required()
def login():

    username = request.args.get('username', None)
    password = request.args.get('password', None)

    # 去除用户名和密码中的首尾空格
    username = username.strip() if username else None
    password = password.strip() if password else None

    if username is None or password is None:
        return jsonify({"msg": "用户名或者密码为空！",'code':400})

    # 尝试查询用户信息  (当没有数据的时候返回值为 None)
    user_info = db.session.query(User).filter(User.username == username).first()

    if user_info is None:
        return jsonify({"msg": "用户名或密码错误",'code':401})

    if user_info.user_status == '0':
        return jsonify({"msg": "账号禁用！", 'code': 400})

    # 如果用户名存在验证密码
    if user_info and password_decryption(password,user_info.password):

        # 最后登录时间修改
        user_info.end_login_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        db.session.commit()

        # token返回
        access_token = create_access_token(identity=username)
        return jsonify({
            'code':200,
            'msg':'登录成功！',
            'access_token': access_token,
            'user_id': user_info.id,
            'datatime_time': datetime.now().strftime("%Y-%m-%d %H:%M"),

        })
    else:
        # 登录失败，返回错误响应
        return jsonify({"msg" :"用户名或密码错误",'code': 401})

# token验证  如果失效 前端回退到登录页面
@user_view.route('/token_refresh', methods=['GET'])
@jwt_required()
def token_refresh():
    username = request.args.get('username')
    access_token = create_access_token(identity=username)
    return jsonify({"access_token" : access_token})


# token验证  如果失效 前端回退到登录页面
@user_view.route('/protected', methods=['GET', 'POST', 'DELETE', 'PUT', 'CATCH'])
# @jwt_required()
def protected():

    # token验证  成功返回信息
    current_user = get_jwt_identity()

    # 查找token对应用户信息返回
    user_info = db.session.query(User).filter(User.username == current_user).first()

    # 获取用户多权限数据
    permission_data = db.session.query(User.id,User.username,Permission.id.label('userpermission_id'),Permission.permission_name,).join(UserPermission,User.id == UserPermission.user_id).\
        join(Permission,UserPermission.permission_id == Permission.id).filter(User.id == user_info.id).all()

    permission_data = [{'permission_id':i.userpermission_id,'permission_name':i.permission_name} for i in permission_data]

    # 序列化
    user_data = convert_folder_to_dict_list(user_info, ['id','username', 'email', 'create_time'])

    # dict数据拼接
    user_data = {**user_data, **{'permission_data':permission_data}}


    return jsonify({
        'logged_in_as': current_user,
        'code':200,
        'user_info': user_data
    })


# 用户注册接口
@user_view.route('/register', methods=['POST'])
def register():

    # 接受所传参数用户信息
    username = request.form.get('username', None)
    name = request.form.get('name', None)
    password = request.form.get('password', None)

    # 去除用户名和密码中的首尾空格
    username = username.strip() if username else None
    password = password.strip() if password else None

    if username is None or password is None:
        return jsonify({
            'code': 400,
            'msg': '用户名和密码必须提供！'
        })

    # 查找用户名称相同用户
    user = db.session.query(User).filter(User.username == username).first()

    if user:
        return jsonify({
            'code': 400,
            'msg': '该用户已经存在！'
        })

    # 创建新用户并将加密后的密码存储到数据库
    new_user = User(username=username, password=password_encryption(password),name=name,user_status=1)
    db.session.add(new_user)
    db.session.commit()

    return jsonify({
            'code': 200,
            'msg': '注册成功！',
    })



# 用户信息展示接口（用户管理）
@user_view.route('/user_data_manage', methods=['GET'])
# @jwt_required()
def user_data_manage():
    # 连表查询用户与用户权限表,权限表所需数据
    res = db.session.query(
        User.id,
        User.name,
        User.username,
        User.user_status,
        User.create_time,
        User.end_login_time,
        # 函数将同一用户的多个权限组合成一个逗号分隔的字符串。
        func.group_concat(Permission.permission_name).label('permissions_name')  # 将权限合并为一个字符串
    ).join(UserPermission, User.id == UserPermission.user_id) \
        .join(Permission, UserPermission.permission_id == Permission.id).all()
    res = convert_folder_to_dict_list(res,['id','name','username','permissions_name','user_status','create_time','end_login_time'])
    return jsonify({'code':200,'data':res})


# 用户信息修改接口（用户管理）
@user_view.route('/user_data_manage_write', methods=['POST'])
# @jwt_required()
def user_data_manage_write():

    # 用户id
    user_id = request.form.get('user_id')
    # 权限id为列表多个
    permission_list_id = request.form.get('permission_list_id',[])
    # 查询用户权限关联表，关于用户对应权限数据，如果查询到用户有该id进行授予，如果不传进行删除操作
    user_permission = db.session.query(UserPermission.permission_id).filter(UserPermission.user_id==user_id).all()
    user_permission = [ i[0] for i in user_permission]
    print(user_permission)
    # 判断传后来权限列表数据是否存在于用户本身拥有数据
    if permission_list_id != '[]':

        permission_list_id = eval(permission_list_id)
        # 将用户现有权限和传入的权限进行对比
        # 需要添加的权限（在 permission_list_id 中但不在 user_permission 中）
        to_add = list(set(permission_list_id) - set(user_permission))

        # 需要删除的权限（在 user_permission 中但不在 permission_list_id 中）
        to_delete = list(set(user_permission) - set(permission_list_id))

        # 添加新权限
        for permission_id in to_add:
            new_permission = UserPermission(user_id=user_id, permission_id=permission_id)
            db.session.add(new_permission)
            print(f"添加权限 {permission_id} 给用户 {user_id}")

        # 删除不再需要的权限
        if to_delete:
            db.session.query(UserPermission).filter(
                UserPermission.user_id == user_id,
                UserPermission.permission_id.in_(to_delete)
            ).delete(synchronize_session=False)
            print(f"删除权限 {to_delete} 从用户 {user_id}")
    else:
        db.session.query(UserPermission).filter(UserPermission.user_id==user_id).delete()

    # 提交
    db.session.commit()
    return jsonify({'code':200,'msg':'用户数据修改成功！'})

# 用户启用状态修改接口（用户管理）
@user_view.route('/user_data_manage_status_update', methods=['POST'])
# @jwt_required()
def user_data_manage_status_update():
    # 用户启用状态  1启用 2禁用
    status = request.form.get('user_status',1)
    # 用户id
    user_id = request.form.get('user_id',None)
    # 当用户id与用户状态存在
    if user_id and status:
        # 查询用户相同并且修改状态
        db.session.query(User).filter(User.id==user_id).update({'user_status':status})
        # 数据提交
        db.session.commit()
        return jsonify({'code':200, 'message':'用户状态修改成功'})
    return jsonify({'code':400, 'message':'用户及状态未输入'})


# 用户信息详情获取（用户管理）
@user_view.route('/user_data_manage_detile', methods=['GET'])
# @jwt_required()
def user_data_manage_detile():

    # 用户id
    user_id = request.args.get('user_id',None)
    # 第几页
    page = request.args.get('page', default=1, type=int)
    # 每页条数
    per_page = request.args.get('per_page', default=15, type=int)

    # 查询用户详情
    user_data_manage = db.session.query(
        User.id,
        User.name,
        User.username,
        # 函数将同一用户的多个权限组合成一个逗号分隔的字符串。
        func.group_concat(UserPermission.permission_id).label('permissions_ids')  # 将权限合并为一个字符串
    ).join(UserPermission,User.id == UserPermission.user_id).filter(User.id==user_id).paginate(page=page, per_page=per_page, error_out=False)

    # 构建返回的 JSON
    response_data = {
        'total_items': user_data_manage.total,
        'total_pages': user_data_manage.pages,
        'current_page': user_data_manage.page,
        'per_page': per_page,
            'data': [
        {'id': i.id, 'name': i.name, 'username': i.username, 'permissions_ids': i.permissions_ids}
        for i in user_data_manage.items
    ]
    }

    return jsonify({'code': 200, 'data': response_data,'msg':'查询成功'})


# 权限相关筛选接口
@user_view.route('/permission_menu_select', methods=['GET'])
# @jwt_required()
def permission_menu_select():
    # 角色列表返回
    permission_data = convert_folder_to_dict_list(db.session.query(Permission).all(),['id','permission_name','permission_content','permission_status','permission_code','created_at'])
    # 菜单列表返回
    menu_list = convert_folder_to_dict_list(db.session.query(Menu).all(),
                                            ['id','menu_name','menu_link','menu_icon','menu_order','menu_parent_id',])

    # 自定义排序函数  按照菜单表自定义顺序来对菜单进行排序
    def custom_sort(menu):
        return menu.get('menu_order', 0)

    # 对菜单项列表进行排序
    sorted_menu_items = sorted(menu_list, key=custom_sort)

    # 从 menu_parent_id为none主节点开始找  （递归找出所有子类菜单）
    def build_tree(data, parent_id=None):
        tree = []
        for item in data:
            if item['menu_parent_id'] == parent_id:
                children = build_tree(data, item['id'])
                if children:
                    item['children'] = children
                tree.append(item)
        return tree

    # 调用方法获取父子菜单组装数据
    menu_list = build_tree(sorted_menu_items)

    data_list = {
        'permission_data':permission_data,
        'menu_list':menu_list,
                }
    return jsonify({'code': 200, 'data': data_list})



